import { log } from "console";
import { appendFile } from "fs";

/**
 * **案例 1：过滤数组中的奇数并输出**打印数组中的所有奇数
 * @param {number[]} nums - 数字数组
 */
function printOddNumbers(nums: number[]): void {
  for (const num of nums) {
    if (num % 2 !== 0) {
      console.log(num);
    }
  }
}

// 调用函数
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
printOddNumbers(numbers);


// 案例 2：查找并输出字符串数组中包含特定子字符串的元素,定义一个函数，接受一个字符串数组，返回void
function logPhrasesWithIs(phrases: string[]): void {
  for (const phrase of phrases) {
    //检查字符串是否包含“is
    if (phrase.includes('is')) {
      //打印符合条件的字符串
      console.log(phrase);
    }

  }
}
// 示例用法
const phrases = ['Hello', 'World', 'is', 'a', 'test'];
logPhrasesWithIs(phrases);

// 案例 3：计算并输出包含负数的数组的正数总和,定义一个函数，接受一个数字数组，返回正数之和
function sumPositiveNumbers(numbers: number[]): number {
  let sum = 0;
  for (const num of numbers) {
    if (num > 0) {
      sum += num;
    }
  }
  return sum
}
const mixedNumbers = [-3, 5. - 1, 8, -2, 7];
const result = sumPositiveNumbers(mixedNumbers);
console.log(`Total sum of positive numbers:${result}`);


// for...in
// 案例 1：遍历对象属性并输出符合条件的属性值
// 定义一个接口描述person对象结构
interface Person {
  name: string;
  age: number;
  city: string;
  occupation: string;
}
// 定义一个函数，接受一个Person类型的对象，返回void
function logStringProperties(person: Person): void {
  for (const key in person) {
    if (person.hasOwnProperty(key)) {//确保key是对象自身的属性
      const value = person[key as keyof Person];
      if (typeof value === 'string') {
        console.log(value);
      }
    }
  }
}
//示例用法
const person: Person = {
  name: 'John',
  age: 30,
  city: 'New York',
  occupation: 'usa'
};
logStringProperties(person);

// 案例 2：计算对象中数值属性的总和
// 定义接口描述data对象的结构
interface Data {
  [key: string | number]: string | number;
  // 可以继续添加其他属性定义
}
// 创建一个函数来计算数值属性的总和
function sumNumericValues(data: Data): number {
  let sum: number = 0;
  for (const key in data) {
    if (typeof data[key] === 'number') {
      sum += data[key] as number;
    }
  }
  return sum;
}
const data: Data = {
  'a': 'apple',
  'b': 'banana',
  'c': 'cherry',
  'd': 10,
  'e': 20,
  'f': 30
}
console.log(sumNumericValues(data));

// 案例 3：查找对象中符合条件的属性并输出键和值
// 定义接口描述inventory对象的结构
interface Inventory {
  [key: string]: number;
}
function printZeroInventory(inventory: Inventory): void {
  for (const key in inventory) {
    if (inventory[key] === 0) {
      console.log(`${key}: ${inventory[key]}`);
    }
  }
}
// 创建一个符合Inventory接口的对象
const inventory: Inventory = {
  apples: 5,
  oranges: 0,
  bananas: 8,
  grapes: 2,
  cherries: 0
};
printZeroInventory(inventory)

//forEach 案例
// 案例 1：查找并输出数组中的正数并计算它们的平均值
function calculatePositiveNumbersAverage(numbers: number[]): number {
  let sum = 0;
  let count = 0;
  numbers.forEach((number) => {
    if (number > 0) {
      sum += number;
      count++;
    }
  });
  const average = count > 0 ? sum / count : 0;//防止除以0的情况
  return average;
}
const number = [-3, 5, -1, 8, -2, 7];
const average = calculatePositiveNumbersAverage(number);
console.log(`平均值: ${average}`);

// 案例 2：查找数组中的字符串长度并输出超过特定长度的字符串
// 定义函数，打印出数组中长度大于给定最小长度的所有单词
function printWordsLongerThan(words: string[], minLength: number): void {
  words.forEach(word => {
    if (word.length > minLength) {
      console.log(word);
    }
  });
}
// 创建一个单词数组
const words1 = ['apple', 'banana', 'cherry', 'date', 'elderberry'];
const minLength2 = 5;
//调用函数
printWordsLongerThan(words1, minLength2);

// map 案例
// 案例 1：将数组中的负数转换为正数
// 定义函数，将数组中的所有数字映射为正数
function mapToPositiveNumbers(numbers: number[]): number[] {
  return numbers.map(num => {
    return num < 0 ? -num : num;
  });

}
// 创建一个包含正数和负数的数组
namespace zuo828 {
  const numbers: number[] = [1, -2, 3, -4, 5];
  const positiveNumbers = mapToPositiveNumbers(numbers);
  console.log(positiveNumbers);
}

// 案例 2：将对象数组中的特定属性值大写化
//定义接口描述people数组中的对象结构
interface Person1 {
  name: string;
  age: number;
}
// 定义函数，将数组中的所有名字长度大于3的转换为大写。
function uppercaseLongNames(people: Person1[]): Person1[] {
  return people.map((person) => {
    return person.name.length > 3 ? {
      ...person, name: person.name.toUpperCase()
    } : person;
  }); 
}
// 创建一个包含Person对象的数组
const people: Person1[] = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
  { name: 'Charlie', age: 35 },
  { name: 'David', age: 40 },
  { name: 'Eve', age: 45 },
];
// 调用函数并打印结果
const uppercaseNames = uppercaseLongNames(people);
console.log(uppercaseNames);

//案例 3：将字符串数组中的特定子字符串替换为另一字符串
// 定义函数，将包含'hello'的字符串替换为'hi'
function replaceHelloWithHi(phrases: string[]): string[]{
  return phrases.map(phrase => {
    return phrase.includes('hello') ?
      phrase.replace('hello', 'hi') : phrase;
  });
}
// 创建一个包含字符串的数组
const phrases1 = ['hello world', 'goodbye world', 'hi there'];
const updatedPhrases = replaceHelloWithHi(phrases1);
console.log(updatedPhrases);

// 使用 map、filter 和 reduce 方法结合的案例
// 案例 1：计算并输出长度大于 5 的字符串的总长度
// 定义函数，计算数组中长度大于 5 的字符串的总长度
function calculateTotalLength(phrases: string[]): number{
  return phrases.filter(phrase => phrase.length > 5).map(phrase => phrase.length).reduce((sum, length) => sum + length, 0);
}
// 创建一个包含字符串的数组
const phrases2 = ['hello', 'world', 'typescript', 'is', 'awesome'];
// 调用函数并打印结果
const totalLength = calculateTotalLength(phrases2);
console.log(`Total length of phrases longer than 5 characters: ${totalLength}`);

// 案例 2：计算正数数组的平方和，并排除负数
// 定义函数，计算数组中所有正数的平方和
function sumOfSquaresOfPositiveNumbers(numbers: number[]): number {
  return numbers
    .filter(num => num > 0)        // 过滤正数
    .map(num => num * num)         // 将每个正数平方
    .reduce((sum, squared) => sum + squared, 0); // 计算平方和
}

// 创建一个包含正数和负数的数组
const numbers2 = [-5, 3, -2, 4, 6, -1];
// 调用函数并打印结果
const squareSum = sumOfSquaresOfPositiveNumbers(numbers2);
console.log(`Sum of squares of positive numbers: ${squareSum}`);

// 案例 3：处理用户数据，提取年龄大于 18 的用户，并计算他们的平均年龄
// 定义接口描述用户对象的结构
interface User {
  name: string;
  age: number;
}
// 定义函数，计算所有年龄大于18岁的用户的平均年龄
function calculateAverageAgeOfAdults(users: User[]): number {
  return users
    .filter(user => user.age > 18) // 过滤年龄大于18的用户
    .map(user => user.age)         // 提取用户年龄
    .reduce((sum, age) => sum + age, 0) / users.length; // 计算平均年龄
}
// 创建一个包含 User 对象的数组
const users: User[] = [
  { name: 'Alice', age: 22 },
  { name: 'Bob', age: 17 },
  { name: 'Charlie', age: 30 },
  { name: 'David', age: 15 }
];
// 调用函数并打印结果
const averageAge = calculateAverageAgeOfAdults(users);
console.log(`Average age of users older than 18: ${averageAge}`);

// 使用 findIndex、splice 方法结合案例
// 案例 1：在购物车中移除指定商品
// 定义接口描述购物车中的对象结构
interface CartItem {
  id: number;
  name: string;
  quantity: number;
}

// 定义函数，从购物车中移除指定ID的商品
function removeItemFromCart(cart: CartItem[], itemIdToRemove: number): void {
  const indexToRemove = cart.findIndex(item => item.id === itemIdToRemove);
  if (indexToRemove !== -1) {
    cart.splice(indexToRemove, 1);
  }
}

// 创建一个购物车数组
const cart: CartItem[] = [
  { id: 1, name: 'Laptop', quantity: 1 },
  { id: 2, name: 'Mouse', quantity: 2 },
  { id: 3, name: 'Keyboard', quantity: 1 }
];

// 定义要移除的商品ID
const itemIdToRemove = 2;

// 调用函数并打印结果
removeItemFromCart(cart, itemIdToRemove);
console.log(cart);

//案例 2：更新数组中的指定对象属性
// 定义接口描述员工对象的结构
interface Employee {
  id: number;
  name: string;
  role: string;
}

// 定义函数，更新指定ID员工的角色
function updateEmployeeRole(employees: Employee[], employeeIdToUpdate: number, newRole: string): void {
  const indexToUpdate = employees.findIndex(employee => employee.id === employeeIdToUpdate);
  if (indexToUpdate !== -1) {
    employees[indexToUpdate].role = newRole;
  }
}

// 创建一个包含 Employee 对象的数组
const employees: Employee[] = [
  { id: 1, name: 'John', role: 'Developer' },
  { id: 2, name: 'Jane', role: 'Designer' },
  { id: 3, name: 'Tom', role: 'Manager' }
];

// 定义要更新的员工ID和新角色
const employeeIdToUpdate = 3;
const newRole = 'Senior Manager';

// 调用函数并打印结果
updateEmployeeRole(employees, employeeIdToUpdate, newRole);
console.log(employees);

// 案例 3：将数组中的第一个负数替换为零
function replaceNegativeNumberWithZero(numbers: number[]): void {
  const indexToReplace = numbers.findIndex(num => num < 0);
  if (indexToReplace !== -1) {
    numbers.splice(indexToReplace, 1, 0);
  }

}

// 创建一个包含正数和负数的数组
const numbers3 = [4, -1, 6, -2, 7];

// 调用函数并打印结果
replaceNegativeNumberWithZero(numbers3);
console.log(numbers3);
































